home *** CD-ROM | disk | FTP | other *** search
/ Aminet 8 / Aminet 8 (1995)(GTI - Schatztruhe)[!][Oct 1995].iso / Aminet / dev / gcc / gcc270_src.lha / gcc-2.7.0-amiga / gcc.info-12 (.txt) < prev    next >
GNU Info File  |  1995-06-16  |  50KB  |  852 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.55 from the input
  2. file gcc.texi.
  3.    This file documents the use and the internals of the GNU compiler.
  4.    Published by the Free Software Foundation 59 Temple Place - Suite 330
  5. Boston, MA 02111-1307 USA
  6.    Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software
  7. Foundation, Inc.
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.    Permission is granted to copy and distribute modified versions of
  12. this manual under the conditions for verbatim copying, provided also
  13. that the sections entitled "GNU General Public License," "Funding for
  14. Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
  15. included exactly as in the original, and provided that the entire
  16. resulting derived work is distributed under the terms of a permission
  17. notice identical to this one.
  18.    Permission is granted to copy and distribute translations of this
  19. manual into another language, under the above conditions for modified
  20. versions, except that the sections entitled "GNU General Public
  21. License," "Funding for Free Software," and "Protect Your Freedom--Fight
  22. `Look And Feel'", and this permission notice, may be included in
  23. translations approved by the Free Software Foundation instead of in the
  24. original English.
  25. File: gcc.info,  Node: Non-bugs,  Next: Warnings and Errors,  Prev: Protoize Caveats,  Up: Trouble
  26. Certain Changes We Don't Want to Make
  27. =====================================
  28.    This section lists changes that people frequently request, but which
  29. we do not make because we think GNU CC is better without them.
  30.    * Checking the number and type of arguments to a function which has
  31.      an old-fashioned definition and no prototype.
  32.      Such a feature would work only occasionally--only for calls that
  33.      appear in the same file as the called function, following the
  34.      definition.  The only way to check all calls reliably is to add a
  35.      prototype for the function.  But adding a prototype eliminates the
  36.      motivation for this feature.  So the feature is not worthwhile.
  37.    * Warning about using an expression whose type is signed as a shift
  38.      count.
  39.      Shift count operands are probably signed more often than unsigned.
  40.      Warning about this would cause far more annoyance than good.
  41.    * Warning about assigning a signed value to an unsigned variable.
  42.      Such assignments must be very common; warning about them would
  43.      cause more annoyance than good.
  44.    * Warning about unreachable code.
  45.      It's very common to have unreachable code in machine-generated
  46.      programs.  For example, this happens normally in some files of GNU
  47.      C itself.
  48.    * Warning when a non-void function value is ignored.
  49.      Coming as I do from a Lisp background, I balk at the idea that
  50.      there is something dangerous about discarding a value.  There are
  51.      functions that return values which some callers may find useful;
  52.      it makes no sense to clutter the program with a cast to `void'
  53.      whenever the value isn't useful.
  54.    * Assuming (for optimization) that the address of an external symbol
  55.      is never zero.
  56.      This assumption is false on certain systems when `#pragma weak' is
  57.      used.
  58.    * Making `-fshort-enums' the default.
  59.      This would cause storage layout to be incompatible with most other
  60.      C compilers.  And it doesn't seem very important, given that you
  61.      can get the same result in other ways.  The case where it matters
  62.      most is when the enumeration-valued object is inside a structure,
  63.      and in that case you can specify a field width explicitly.
  64.    * Making bitfields unsigned by default on particular machines where
  65.      "the ABI standard" says to do so.
  66.      The ANSI C standard leaves it up to the implementation whether a
  67.      bitfield declared plain `int' is signed or not.  This in effect
  68.      creates two alternative dialects of C.
  69.      The GNU C compiler supports both dialects; you can specify the
  70.      signed dialect with `-fsigned-bitfields' and the unsigned dialect
  71.      with `-funsigned-bitfields'.  However, this leaves open the
  72.      question of which dialect to use by default.
  73.      Currently, the preferred dialect makes plain bitfields signed,
  74.      because this is simplest.  Since `int' is the same as `signed int'
  75.      in every other context, it is cleanest for them to be the same in
  76.      bitfields as well.
  77.      Some computer manufacturers have published Application Binary
  78.      Interface standards which specify that plain bitfields should be
  79.      unsigned.  It is a mistake, however, to say anything about this
  80.      issue in an ABI.  This is because the handling of plain bitfields
  81.      distinguishes two dialects of C.  Both dialects are meaningful on
  82.      every type of machine.  Whether a particular object file was
  83.      compiled using signed bitfields or unsigned is of no concern to
  84.      other object files, even if they access the same bitfields in the
  85.      same data structures.
  86.      A given program is written in one or the other of these two
  87.      dialects.  The program stands a chance to work on most any machine
  88.      if it is compiled with the proper dialect.  It is unlikely to work
  89.      at all if compiled with the wrong dialect.
  90.      Many users appreciate the GNU C compiler because it provides an
  91.      environment that is uniform across machines.  These users would be
  92.      inconvenienced if the compiler treated plain bitfields differently
  93.      on certain machines.
  94.      Occasionally users write programs intended only for a particular
  95.      machine type.  On these occasions, the users would benefit if the
  96.      GNU C compiler were to support by default the same dialect as the
  97.      other compilers on that machine.  But such applications are rare.
  98.      And users writing a program to run on more than one type of
  99.      machine cannot possibly benefit from this kind of compatibility.
  100.      This is why GNU CC does and will treat plain bitfields in the same
  101.      fashion on all types of machines (by default).
  102.      There are some arguments for making bitfields unsigned by default
  103.      on all machines.  If, for example, this becomes a universal de
  104.      facto standard, it would make sense for GNU CC to go along with
  105.      it.  This is something to be considered in the future.
  106.      (Of course, users strongly concerned about portability should
  107.      indicate explicitly in each bitfield whether it is signed or not.
  108.      In this way, they write programs which have the same meaning in
  109.      both C dialects.)
  110.    * Undefining `__STDC__' when `-ansi' is not used.
  111.      Currently, GNU CC defines `__STDC__' as long as you don't use
  112.      `-traditional'.  This provides good results in practice.
  113.      Programmers normally use conditionals on `__STDC__' to ask whether
  114.      it is safe to use certain features of ANSI C, such as function
  115.      prototypes or ANSI token concatenation.  Since plain `gcc' supports
  116.      all the features of ANSI C, the correct answer to these questions
  117.      is "yes".
  118.      Some users try to use `__STDC__' to check for the availability of
  119.      certain library facilities.  This is actually incorrect usage in
  120.      an ANSI C program, because the ANSI C standard says that a
  121.      conforming freestanding implementation should define `__STDC__'
  122.      even though it does not have the library facilities.  `gcc -ansi
  123.      -pedantic' is a conforming freestanding implementation, and it is
  124.      therefore required to define `__STDC__', even though it does not
  125.      come with an ANSI C library.
  126.      Sometimes people say that defining `__STDC__' in a compiler that
  127.      does not completely conform to the ANSI C standard somehow
  128.      violates the standard.  This is illogical.  The standard is a
  129.      standard for compilers that claim to support ANSI C, such as `gcc
  130.      -ansi'--not for other compilers such as plain `gcc'.  Whatever the
  131.      ANSI C standard says is relevant to the design of plain `gcc'
  132.      without `-ansi' only for pragmatic reasons, not as a requirement.
  133.    * Undefining `__STDC__' in C++.
  134.      Programs written to compile with C++-to-C translators get the
  135.      value of `__STDC__' that goes with the C compiler that is
  136.      subsequently used.  These programs must test `__STDC__' to
  137.      determine what kind of C preprocessor that compiler uses: whether
  138.      they should concatenate tokens in the ANSI C fashion or in the
  139.      traditional fashion.
  140.      These programs work properly with GNU C++ if `__STDC__' is defined.
  141.      They would not work otherwise.
  142.      In addition, many header files are written to provide prototypes
  143.      in ANSI C but not in traditional C.  Many of these header files
  144.      can work without change in C++ provided `__STDC__' is defined.  If
  145.      `__STDC__' is not defined, they will all fail, and will all need
  146.      to be changed to test explicitly for C++ as well.
  147.    * Deleting "empty" loops.
  148.      GNU CC does not delete "empty" loops because the most likely reason
  149.      you would put one in a program is to have a delay.  Deleting them
  150.      will not make real programs run any faster, so it would be
  151.      pointless.
  152.      It would be different if optimization of a nonempty loop could
  153.      produce an empty one.  But this generally can't happen.
  154.    * Making side effects happen in the same order as in some other
  155.      compiler.
  156.      It is never safe to depend on the order of evaluation of side
  157.      effects.  For example, a function call like this may very well
  158.      behave differently from one compiler to another:
  159.           void func (int, int);
  160.           
  161.           int i = 2;
  162.           func (i++, i++);
  163.      There is no guarantee (in either the C or the C++ standard language
  164.      definitions) that the increments will be evaluated in any
  165.      particular order.  Either increment might happen first.  `func'
  166.      might get the arguments `2, 3', or it might get `3, 2', or even
  167.      `2, 2'.
  168.    * Not allowing structures with volatile fields in registers.
  169.      Strictly speaking, there is no prohibition in the ANSI C standard
  170.      against allowing structures with volatile fields in registers, but
  171.      it does not seem to make any sense and is probably not what you
  172.      wanted to do.  So the compiler will give an error message in this
  173.      case.
  174. File: gcc.info,  Node: Warnings and Errors,  Prev: Non-bugs,  Up: Trouble
  175. Warning Messages and Error Messages
  176. ===================================
  177.    The GNU compiler can produce two kinds of diagnostics: errors and
  178. warnings.  Each kind has a different purpose:
  179.      *Errors* report problems that make it impossible to compile your
  180.      program.  GNU CC reports errors with the source file name and line
  181.      number where the problem is apparent.
  182.      *Warnings* report other unusual conditions in your code that *may*
  183.      indicate a problem, although compilation can (and does) proceed.
  184.      Warning messages also report the source file name and line number,
  185.      but include the text `warning:' to distinguish them from error
  186.      messages.
  187.    Warnings may indicate danger points where you should check to make
  188. sure that your program really does what you intend; or the use of
  189. obsolete features; or the use of nonstandard features of GNU C or C++.
  190. Many warnings are issued only if you ask for them, with one of the `-W'
  191. options (for instance, `-Wall' requests a variety of useful warnings).
  192.    GNU CC always tries to compile your program if possible; it never
  193. gratuitously rejects a program whose meaning is clear merely because
  194. (for instance) it fails to conform to a standard.  In some cases,
  195. however, the C and C++ standards specify that certain extensions are
  196. forbidden, and a diagnostic *must* be issued by a conforming compiler.
  197. The `-pedantic' option tells GNU CC to issue warnings in such cases;
  198. `-pedantic-errors' says to make them errors instead.  This does not
  199. mean that *all* non-ANSI constructs get warnings or errors.
  200.    *Note Options to Request or Suppress Warnings: Warning Options, for
  201. more detail on these and related command-line options.
  202. File: gcc.info,  Node: Bugs,  Next: Service,  Prev: Trouble,  Up: Top
  203. Reporting Bugs
  204. **************
  205.    Your bug reports play an essential role in making GNU CC reliable.
  206.    When you encounter a problem, the first thing to do is to see if it
  207. is already known.  *Note Trouble::.  If it isn't known, then you should
  208. report the problem.
  209.    Reporting a bug may help you by bringing a solution to your problem,
  210. or it may not.  (If it does not, look in the service directory; see
  211. *Note Service::.)  In any case, the principal function of a bug report
  212. is to help the entire community by making the next version of GNU CC
  213. work better.  Bug reports are your contribution to the maintenance of
  214. GNU CC.
  215.    Since the maintainers are very overloaded, we cannot respond to every
  216. bug report.  However, if the bug has not been fixed, we are likely to
  217. send you a patch and ask you to tell us whether it works.
  218.    In order for a bug report to serve its purpose, you must include the
  219. information that makes for fixing the bug.
  220. * Menu:
  221. * Criteria:  Bug Criteria.   Have you really found a bug?
  222. * Where: Bug Lists.         Where to send your bug report.
  223. * Reporting: Bug Reporting.  How to report a bug effectively.
  224. * Patches: Sending Patches.  How to send a patch for GNU CC.
  225. * Known: Trouble.            Known problems.
  226. * Help: Service.             Where to ask for help.
  227. File: gcc.info,  Node: Bug Criteria,  Next: Bug Lists,  Up: Bugs
  228. Have You Found a Bug?
  229. =====================
  230.    If you are not sure whether you have found a bug, here are some
  231. guidelines:
  232.    * If the compiler gets a fatal signal, for any input whatever, that
  233.      is a compiler bug.  Reliable compilers never crash.
  234.    * If the compiler produces invalid assembly code, for any input
  235.      whatever (except an `asm' statement), that is a compiler bug,
  236.      unless the compiler reports errors (not just warnings) which would
  237.      ordinarily prevent the assembler from being run.
  238.    * If the compiler produces valid assembly code that does not
  239.      correctly execute the input source code, that is a compiler bug.
  240.      However, you must double-check to make sure, because you may have
  241.      run into an incompatibility between GNU C and traditional C (*note
  242.      Incompatibilities::.).  These incompatibilities might be considered
  243.      bugs, but they are inescapable consequences of valuable features.
  244.      Or you may have a program whose behavior is undefined, which
  245.      happened by chance to give the desired results with another C or
  246.      C++ compiler.
  247.      For example, in many nonoptimizing compilers, you can write `x;'
  248.      at the end of a function instead of `return x;', with the same
  249.      results.  But the value of the function is undefined if `return'
  250.      is omitted; it is not a bug when GNU CC produces different results.
  251.      Problems often result from expressions with two increment
  252.      operators, as in `f (*p++, *p++)'.  Your previous compiler might
  253.      have interpreted that expression the way you intended; GNU CC might
  254.      interpret it another way.  Neither compiler is wrong.  The bug is
  255.      in your code.
  256.      After you have localized the error to a single source line, it
  257.      should be easy to check for these things.  If your program is
  258.      correct and well defined, you have found a compiler bug.
  259.    * If the compiler produces an error message for valid input, that is
  260.      a compiler bug.
  261.    * If the compiler does not produce an error message for invalid
  262.      input, that is a compiler bug.  However, you should note that your
  263.      idea of "invalid input" might be my idea of "an extension" or
  264.      "support for traditional practice".
  265.    * If you are an experienced user of C or C++ compilers, your
  266.      suggestions for improvement of GNU CC or GNU C++ are welcome in
  267.      any case.
  268. File: gcc.info,  Node: Bug Lists,  Next: Bug Reporting,  Prev: Bug Criteria,  Up: Bugs
  269. Where to Report Bugs
  270. ====================
  271.    Send bug reports for GNU C to `bug-gcc@prep.ai.mit.edu'.
  272.    Send bug reports for GNU C++ to `bug-g++@prep.ai.mit.edu'.  If your
  273. bug involves the C++ class library libg++, send mail to
  274. `bug-lib-g++@prep.ai.mit.edu'.  If you're not sure, you can send the
  275. bug report to both lists.
  276.    *Do not send bug reports to `help-gcc@prep.ai.mit.edu' or to the
  277. newsgroup `gnu.gcc.help'.* Most users of GNU CC do not want to receive
  278. bug reports.  Those that do, have asked to be on `bug-gcc' and/or
  279. `bug-g++'.
  280.    The mailing lists `bug-gcc' and `bug-g++' both have newsgroups which
  281. serve as repeaters: `gnu.gcc.bug' and `gnu.g++.bug'.  Each mailing list
  282. and its newsgroup carry exactly the same messages.
  283.    Often people think of posting bug reports to the newsgroup instead of
  284. mailing them.  This appears to work, but it has one problem which can be
  285. crucial: a newsgroup posting does not contain a mail path back to the
  286. sender.  Thus, if maintainers need more information, they may be unable
  287. to reach you.  For this reason, you should always send bug reports by
  288. mail to the proper mailing list.
  289.    As a last resort, send bug reports on paper to:
  290.      GNU Compiler Bugs
  291.      Free Software Foundation
  292.      675 Mass Ave
  293.      Cambridge, MA 02139
  294. File: gcc.info,  Node: Bug Reporting,  Next: Sending Patches,  Prev: Bug Lists,  Up: Bugs
  295. How to Report Bugs
  296. ==================
  297.    The fundamental principle of reporting bugs usefully is this:
  298. *report all the facts*.  If you are not sure whether to state a fact or
  299. leave it out, state it!
  300.    Often people omit facts because they think they know what causes the
  301. problem and they conclude that some details don't matter.  Thus, you
  302. might assume that the name of the variable you use in an example does
  303. not matter.  Well, probably it doesn't, but one cannot be sure.
  304. Perhaps the bug is a stray memory reference which happens to fetch from
  305. the location where that name is stored in memory; perhaps, if the name
  306. were different, the contents of that location would fool the compiler
  307. into doing the right thing despite the bug.  Play it safe and give a
  308. specific, complete example.  That is the easiest thing for you to do,
  309. and the most helpful.
  310.    Keep in mind that the purpose of a bug report is to enable someone to
  311. fix the bug if it is not known.  It isn't very important what happens if
  312. the bug is already known.  Therefore, always write your bug reports on
  313. the assumption that the bug is not known.
  314.    Sometimes people give a few sketchy facts and ask, "Does this ring a
  315. bell?"  This cannot help us fix a bug, so it is basically useless.  We
  316. respond by asking for enough details to enable us to investigate.  You
  317. might as well expedite matters by sending them to begin with.
  318.    Try to make your bug report self-contained.  If we have to ask you
  319. for more information, it is best if you include all the previous
  320. information in your response, as well as the information that was
  321. missing.
  322.    Please report each bug in a separate message.  This makes it easier
  323. for us to track which bugs have been fixed and to forward your bugs
  324. reports to the appropriate maintainer.
  325.    Do not compress and encode any part of your bug report using programs
  326. such as `uuencode'.  If you do so it will slow down the processing of
  327. your bug.  If you must submit multiple large files, use `shar', which
  328. allows us to read your message without having to run any decompression
  329. programs.
  330.    To enable someone to investigate the bug, you should include all
  331. these things:
  332.    * The version of GNU CC.  You can get this by running it with the
  333.      `-v' option.
  334.      Without this, we won't know whether there is any point in looking
  335.      for the bug in the current version of GNU CC.
  336.    * A complete input file that will reproduce the bug.  If the bug is
  337.      in the C preprocessor, send a source file and any header files
  338.      that it requires.  If the bug is in the compiler proper (`cc1'),
  339.      run your source file through the C preprocessor by doing `gcc -E
  340.      SOURCEFILE > OUTFILE', then include the contents of OUTFILE in the
  341.      bug report.  (When you do this, use the same `-I', `-D' or `-U'
  342.      options that you used in actual compilation.)
  343.      A single statement is not enough of an example.  In order to
  344.      compile it, it must be embedded in a complete file of compiler
  345.      input; and the bug might depend on the details of how this is done.
  346.      Without a real example one can compile, all anyone can do about
  347.      your bug report is wish you luck.  It would be futile to try to
  348.      guess how to provoke the bug.  For example, bugs in register
  349.      allocation and reloading frequently depend on every little detail
  350.      of the function they happen in.
  351.      Even if the input file that fails comes from a GNU program, you
  352.      should still send the complete test case.  Don't ask the GNU CC
  353.      maintainers to do the extra work of obtaining the program in
  354.      question--they are all overworked as it is.  Also, the problem may
  355.      depend on what is in the header files on your system; it is
  356.      unreliable for the GNU CC maintainers to try the problem with the
  357.      header files available to them.  By sending CPP output, you can
  358.      eliminate this source of uncertainty and save us a certain
  359.      percentage of wild goose chases.
  360.    * The command arguments you gave GNU CC or GNU C++ to compile that
  361.      example and observe the bug.  For example, did you use `-O'?  To
  362.      guarantee you won't omit something important, list all the options.
  363.      If we were to try to guess the arguments, we would probably guess
  364.      wrong and then we would not encounter the bug.
  365.    * The type of machine you are using, and the operating system name
  366.      and version number.
  367.    * The operands you gave to the `configure' command when you installed
  368.      the compiler.
  369.    * A complete list of any modifications you have made to the compiler
  370.      source.  (We don't promise to investigate the bug unless it
  371.      happens in an unmodified compiler.  But if you've made
  372.      modifications and don't tell us, then you are sending us on a wild
  373.      goose chase.)
  374.      Be precise about these changes.  A description in English is not
  375.      enough--send a context diff for them.
  376.      Adding files of your own (such as a machine description for a
  377.      machine we don't support) is a modification of the compiler source.
  378.    * Details of any other deviations from the standard procedure for
  379.      installing GNU CC.
  380.    * A description of what behavior you observe that you believe is
  381.      incorrect.  For example, "The compiler gets a fatal signal," or,
  382.      "The assembler instruction at line 208 in the output is incorrect."
  383.      Of course, if the bug is that the compiler gets a fatal signal,
  384.      then one can't miss it.  But if the bug is incorrect output, the
  385.      maintainer might not notice unless it is glaringly wrong.  None of
  386.      us has time to study all the assembler code from a 50-line C
  387.      program just on the chance that one instruction might be wrong.
  388.      We need *you* to do this part!
  389.      Even if the problem you experience is a fatal signal, you should
  390.      still say so explicitly.  Suppose something strange is going on,
  391.      such as, your copy of the compiler is out of synch, or you have
  392.      encountered a bug in the C library on your system.  (This has
  393.      happened!)  Your copy might crash and the copy here would not.  If
  394.      you said to expect a crash, then when the compiler here fails to
  395.      crash, we would know that the bug was not happening.  If you don't
  396.      say to expect a crash, then we would not know whether the bug was
  397.      happening.  We would not be able to draw any conclusion from our
  398.      observations.
  399.      If the problem is a diagnostic when compiling GNU CC with some
  400.      other compiler, say whether it is a warning or an error.
  401.      Often the observed symptom is incorrect output when your program
  402.      is run.  Sad to say, this is not enough information unless the
  403.      program is short and simple.  None of us has time to study a large
  404.      program to figure out how it would work if compiled correctly,
  405.      much less which line of it was compiled wrong.  So you will have
  406.      to do that.  Tell us which source line it is, and what incorrect
  407.      result happens when that line is executed.  A person who
  408.      understands the program can find this as easily as finding a bug
  409.      in the program itself.
  410.    * If you send examples of assembler code output from GNU CC or GNU
  411.      C++, please use `-g' when you make them.  The debugging information
  412.      includes source line numbers which are essential for correlating
  413.      the output with the input.
  414.    * If you wish to mention something in the GNU CC source, refer to it
  415.      by context, not by line number.
  416.      The line numbers in the development sources don't match those in
  417.      your sources.  Your line numbers would convey no useful
  418.      information to the maintainers.
  419.    * Additional information from a debugger might enable someone to
  420.      find a problem on a machine which he does not have available.
  421.      However, you need to think when you collect this information if
  422.      you want it to have any chance of being useful.
  423.      For example, many people send just a backtrace, but that is never
  424.      useful by itself.  A simple backtrace with arguments conveys little
  425.      about GNU CC because the compiler is largely data-driven; the same
  426.      functions are called over and over for different RTL insns, doing
  427.      different things depending on the details of the insn.
  428.      Most of the arguments listed in the backtrace are useless because
  429.      they are pointers to RTL list structure.  The numeric values of the
  430.      pointers, which the debugger prints in the backtrace, have no
  431.      significance whatever; all that matters is the contents of the
  432.      objects they point to (and most of the contents are other such
  433.      pointers).
  434.      In addition, most compiler passes consist of one or more loops that
  435.      scan the RTL insn sequence.  The most vital piece of information
  436.      about such a loop--which insn it has reached--is usually in a
  437.      local variable, not in an argument.
  438.      What you need to provide in addition to a backtrace are the values
  439.      of the local variables for several stack frames up.  When a local
  440.      variable or an argument is an RTX, first print its value and then
  441.      use the GDB command `pr' to print the RTL expression that it points
  442.      to.  (If GDB doesn't run on your machine, use your debugger to call
  443.      the function `debug_rtx' with the RTX as an argument.)  In
  444.      general, whenever a variable is a pointer, its value is no use
  445.      without the data it points to.
  446.    Here are some things that are not necessary:
  447.    * A description of the envelope of the bug.
  448.      Often people who encounter a bug spend a lot of time investigating
  449.      which changes to the input file will make the bug go away and which
  450.      changes will not affect it.
  451.      This is often time consuming and not very useful, because the way
  452.      we will find the bug is by running a single example under the
  453.      debugger with breakpoints, not by pure deduction from a series of
  454.      examples.  You might as well save your time for something else.
  455.      Of course, if you can find a simpler example to report *instead* of
  456.      the original one, that is a convenience.  Errors in the output
  457.      will be easier to spot, running under the debugger will take less
  458.      time, etc.  Most GNU CC bugs involve just one function, so the
  459.      most straightforward way to simplify an example is to delete all
  460.      the function definitions except the one where the bug occurs.
  461.      Those earlier in the file may be replaced by external declarations
  462.      if the crucial function depends on them.  (Exception: inline
  463.      functions may affect compilation of functions defined later in the
  464.      file.)
  465.      However, simplification is not vital; if you don't want to do this,
  466.      report the bug anyway and send the entire test case you used.
  467.    * In particular, some people insert conditionals `#ifdef BUG' around
  468.      a statement which, if removed, makes the bug not happen.  These
  469.      are just clutter; we won't pay any attention to them anyway.
  470.      Besides, you should send us cpp output, and that can't have
  471.      conditionals.
  472.    * A patch for the bug.
  473.      A patch for the bug is useful if it is a good one.  But don't omit
  474.      the necessary information, such as the test case, on the
  475.      assumption that a patch is all we need.  We might see problems
  476.      with your patch and decide to fix the problem another way, or we
  477.      might not understand it at all.
  478.      Sometimes with a program as complicated as GNU CC it is very hard
  479.      to construct an example that will make the program follow a
  480.      certain path through the code.  If you don't send the example, we
  481.      won't be able to construct one, so we won't be able to verify that
  482.      the bug is fixed.
  483.      And if we can't understand what bug you are trying to fix, or why
  484.      your patch should be an improvement, we won't install it.  A test
  485.      case will help us to understand.
  486.      *Note Sending Patches::, for guidelines on how to make it easy for
  487.      us to understand and install your patches.
  488.    * A guess about what the bug is or what it depends on.
  489.      Such guesses are usually wrong.  Even I can't guess right about
  490.      such things without first using the debugger to find the facts.
  491.    * A core dump file.
  492.      We have no way of examining a core dump for your type of machine
  493.      unless we have an identical system--and if we do have one, we
  494.      should be able to reproduce the crash ourselves.
  495. File: gcc.info,  Node: Sending Patches,  Prev: Bug Reporting,  Up: Bugs
  496. Sending Patches for GNU CC
  497. ==========================
  498.    If you would like to write bug fixes or improvements for the GNU C
  499. compiler, that is very helpful.  Send suggested fixes to the bug report
  500. mailing list, `bug-gcc@prep.ai.mit.edu'.
  501.    Please follow these guidelines so we can study your patches
  502. efficiently.  If you don't follow these guidelines, your information
  503. might still be useful, but using it will take extra work.  Maintaining
  504. GNU C is a lot of work in the best of circumstances, and we can't keep
  505. up unless you do your best to help.
  506.    * Send an explanation with your changes of what problem they fix or
  507.      what improvement they bring about.  For a bug fix, just include a
  508.      copy of the bug report, and explain why the change fixes the bug.
  509.      (Referring to a bug report is not as good as including it, because
  510.      then we will have to look it up, and we have probably already
  511.      deleted it if we've already fixed the bug.)
  512.    * Always include a proper bug report for the problem you think you
  513.      have fixed.  We need to convince ourselves that the change is
  514.      right before installing it.  Even if it is right, we might have
  515.      trouble judging it if we don't have a way to reproduce the problem.
  516.    * Include all the comments that are appropriate to help people
  517.      reading the source in the future understand why this change was
  518.      needed.
  519.    * Don't mix together changes made for different reasons.  Send them
  520.      *individually*.
  521.      If you make two changes for separate reasons, then we might not
  522.      want to install them both.  We might want to install just one.  If
  523.      you send them all jumbled together in a single set of diffs, we
  524.      have to do extra work to disentangle them--to figure out which
  525.      parts of the change serve which purpose.  If we don't have time
  526.      for this, we might have to ignore your changes entirely.
  527.      If you send each change as soon as you have written it, with its
  528.      own explanation, then the two changes never get tangled up, and we
  529.      can consider each one properly without any extra work to
  530.      disentangle them.
  531.      Ideally, each change you send should be impossible to subdivide
  532.      into parts that we might want to consider separately, because each
  533.      of its parts gets its motivation from the other parts.
  534.    * Send each change as soon as that change is finished.  Sometimes
  535.      people think they are helping us by accumulating many changes to
  536.      send them all together.  As explained above, this is absolutely
  537.      the worst thing you could do.
  538.      Since you should send each change separately, you might as well
  539.      send it right away.  That gives us the option of installing it
  540.      immediately if it is important.
  541.    * Use `diff -c' to make your diffs.  Diffs without context are hard
  542.      for us to install reliably.  More than that, they make it hard for
  543.      us to study the diffs to decide whether we want to install them.
  544.      Unidiff format is better than contextless diffs, but not as easy
  545.      to read as `-c' format.
  546.      If you have GNU diff, use `diff -cp', which shows the name of the
  547.      function that each change occurs in.
  548.    * Write the change log entries for your changes.  We get lots of
  549.      changes, and we don't have time to do all the change log writing
  550.      ourselves.
  551.      Read the `ChangeLog' file to see what sorts of information to put
  552.      in, and to learn the style that we use.  The purpose of the change
  553.      log is to show people where to find what was changed.  So you need
  554.      to be specific about what functions you changed; in large
  555.      functions, it's often helpful to indicate where within the
  556.      function the change was.
  557.      On the other hand, once you have shown people where to find the
  558.      change, you need not explain its purpose.  Thus, if you add a new
  559.      function, all you need to say about it is that it is new.  If you
  560.      feel that the purpose needs explaining, it probably does--but the
  561.      explanation will be much more useful if you put it in comments in
  562.      the code.
  563.      If you would like your name to appear in the header line for who
  564.      made the change, send us the header line.
  565.    * When you write the fix, keep in mind that we can't install a
  566.      change that would break other systems.
  567.      People often suggest fixing a problem by changing
  568.      machine-independent files such as `toplev.c' to do something
  569.      special that a particular system needs.  Sometimes it is totally
  570.      obvious that such changes would break GNU CC for almost all users.
  571.      We can't possibly make a change like that.  At best it might tell
  572.      us how to write another patch that would solve the problem
  573.      acceptably.
  574.      Sometimes people send fixes that *might* be an improvement in
  575.      general--but it is hard to be sure of this.  It's hard to install
  576.      such changes because we have to study them very carefully.  Of
  577.      course, a good explanation of the reasoning by which you concluded
  578.      the change was correct can help convince us.
  579.      The safest changes are changes to the configuration files for a
  580.      particular machine.  These are safe because they can't create new
  581.      bugs on other machines.
  582.      Please help us keep up with the workload by designing the patch in
  583.      a form that is good to install.
  584. File: gcc.info,  Node: Service,  Next: VMS,  Prev: Bugs,  Up: Top
  585. How To Get Help with GNU CC
  586. ***************************
  587.    If you need help installing, using or changing GNU CC, there are two
  588. ways to find it:
  589.    * Send a message to a suitable network mailing list.  First try
  590.      `bug-gcc@prep.ai.mit.edu', and if that brings no response, try
  591.      `help-gcc@prep.ai.mit.edu'.
  592.    * Look in the service directory for someone who might help you for a
  593.      fee.  The service directory is found in the file named `SERVICE'
  594.      in the GNU CC distribution.
  595. File: gcc.info,  Node: VMS,  Next: Portability,  Prev: Service,  Up: Top
  596. Using GNU CC on VMS
  597. *******************
  598.    Here is how to use GNU CC on VMS.
  599. * Menu:
  600. * Include Files and VMS::  Where the preprocessor looks for the include files.
  601. * Global Declarations::    How to do globaldef, globalref and globalvalue with
  602.                            GNU CC.
  603. * VMS Misc::           Misc information.
  604. File: gcc.info,  Node: Include Files and VMS,  Next: Global Declarations,  Up: VMS
  605. Include Files and VMS
  606. =====================
  607.    Due to the differences between the filesystems of Unix and VMS, GNU
  608. CC attempts to translate file names in `#include' into names that VMS
  609. will understand.  The basic strategy is to prepend a prefix to the
  610. specification of the include file, convert the whole filename to a VMS
  611. filename, and then try to open the file.  GNU CC tries various prefixes
  612. one by one until one of them succeeds:
  613.   1. The first prefix is the `GNU_CC_INCLUDE:' logical name: this is
  614.      where GNU C header files are traditionally stored.  If you wish to
  615.      store header files in non-standard locations, then you can assign
  616.      the logical `GNU_CC_INCLUDE' to be a search list, where each
  617.      element of the list is suitable for use with a rooted logical.
  618.   2. The next prefix tried is `SYS$SYSROOT:[SYSLIB.]'.  This is where
  619.      VAX-C header files are traditionally stored.
  620.   3. If the include file specification by itself is a valid VMS
  621.      filename, the preprocessor then uses this name with no prefix in
  622.      an attempt to open the include file.
  623.   4. If the file specification is not a valid VMS filename (i.e. does
  624.      not contain a device or a directory specifier, and contains a `/'
  625.      character), the preprocessor tries to convert it from Unix syntax
  626.      to VMS syntax.
  627.      Conversion works like this: the first directory name becomes a
  628.      device, and the rest of the directories are converted into
  629.      VMS-format directory names.  For example, the name `X11/foobar.h'
  630.      is translated to `X11:[000000]foobar.h' or `X11:foobar.h',
  631.      whichever one can be opened.  This strategy allows you to assign a
  632.      logical name to point to the actual location of the header files.
  633.   5. If none of these strategies succeeds, the `#include' fails.
  634.    Include directives of the form:
  635.      #include foobar
  636. are a common source of incompatibility between VAX-C and GNU CC.  VAX-C
  637. treats this much like a standard `#include <foobar.h>' directive.  That
  638. is incompatible with the ANSI C behavior implemented by GNU CC: to
  639. expand the name `foobar' as a macro.  Macro expansion should eventually
  640. yield one of the two standard formats for `#include':
  641.      #include "FILE"
  642.      #include <FILE>
  643.    If you have this problem, the best solution is to modify the source
  644. to convert the `#include' directives to one of the two standard forms.
  645. That will work with either compiler.  If you want a quick and dirty fix,
  646. define the file names as macros with the proper expansion, like this:
  647.      #define stdio <stdio.h>
  648. This will work, as long as the name doesn't conflict with anything else
  649. in the program.
  650.    Another source of incompatibility is that VAX-C assumes that:
  651.      #include "foobar"
  652. is actually asking for the file `foobar.h'.  GNU CC does not make this
  653. assumption, and instead takes what you ask for literally; it tries to
  654. read the file `foobar'.  The best way to avoid this problem is to
  655. always specify the desired file extension in your include directives.
  656.    GNU CC for VMS is distributed with a set of include files that is
  657. sufficient to compile most general purpose programs.  Even though the
  658. GNU CC distribution does not contain header files to define constants
  659. and structures for some VMS system-specific functions, there is no
  660. reason why you cannot use GNU CC with any of these functions.  You first
  661. may have to generate or create header files, either by using the public
  662. domain utility `UNSDL' (which can be found on a DECUS tape), or by
  663. extracting the relevant modules from one of the system macro libraries,
  664. and using an editor to construct a C header file.
  665.    A `#include' file name cannot contain a DECNET node name.  The
  666. preprocessor reports an I/O error if you attempt to use a node name,
  667. whether explicitly, or implicitly via a logical name.
  668. File: gcc.info,  Node: Global Declarations,  Next: VMS Misc,  Prev: Include Files and VMS,  Up: VMS
  669. Global Declarations and VMS
  670. ===========================
  671.    GNU CC does not provide the `globalref', `globaldef' and
  672. `globalvalue' keywords of VAX-C.  You can get the same effect with an
  673. obscure feature of GAS, the GNU assembler.  (This requires GAS version
  674. 1.39 or later.)  The following macros allow you to use this feature in
  675. a fairly natural way:
  676.      #ifdef __GNUC__
  677.      #define GLOBALREF(TYPE,NAME)                      \
  678.        TYPE NAME                                       \
  679.        asm ("_$$PsectAttributes_GLOBALSYMBOL$$" #NAME)
  680.      #define GLOBALDEF(TYPE,NAME,VALUE)                \
  681.        TYPE NAME                                       \
  682.        asm ("_$$PsectAttributes_GLOBALSYMBOL$$" #NAME) \
  683.          = VALUE
  684.      #define GLOBALVALUEREF(TYPE,NAME)                 \
  685.        const TYPE NAME[1]                              \
  686.        asm ("_$$PsectAttributes_GLOBALVALUE$$" #NAME)
  687.      #define GLOBALVALUEDEF(TYPE,NAME,VALUE)           \
  688.        const TYPE NAME[1]                              \
  689.        asm ("_$$PsectAttributes_GLOBALVALUE$$" #NAME)  \
  690.          = {VALUE}
  691.      #else
  692.      #define GLOBALREF(TYPE,NAME) \
  693.        globalref TYPE NAME
  694.      #define GLOBALDEF(TYPE,NAME,VALUE) \
  695.        globaldef TYPE NAME = VALUE
  696.      #define GLOBALVALUEDEF(TYPE,NAME,VALUE) \
  697.        globalvalue TYPE NAME = VALUE
  698.      #define GLOBALVALUEREF(TYPE,NAME) \
  699.        globalvalue TYPE NAME
  700.      #endif
  701. (The `_$$PsectAttributes_GLOBALSYMBOL' prefix at the start of the name
  702. is removed by the assembler, after it has modified the attributes of
  703. the symbol).  These macros are provided in the VMS binaries
  704. distribution in a header file `GNU_HACKS.H'.  An example of the usage
  705.      GLOBALREF (int, ijk);
  706.      GLOBALDEF (int, jkl, 0);
  707.    The macros `GLOBALREF' and `GLOBALDEF' cannot be used
  708. straightforwardly for arrays, since there is no way to insert the array
  709. dimension into the declaration at the right place.  However, you can
  710. declare an array with these macros if you first define a typedef for the
  711. array type, like this:
  712.      typedef int intvector[10];
  713.      GLOBALREF (intvector, foo);
  714.    Array and structure initializers will also break the macros; you can
  715. define the initializer to be a macro of its own, or you can expand the
  716. `GLOBALDEF' macro by hand.  You may find a case where you wish to use
  717. the `GLOBALDEF' macro with a large array, but you are not interested in
  718. explicitly initializing each element of the array.  In such cases you
  719. can use an initializer like: `{0,}', which will initialize the entire
  720. array to `0'.
  721.    A shortcoming of this implementation is that a variable declared with
  722. `GLOBALVALUEREF' or `GLOBALVALUEDEF' is always an array.  For example,
  723. the declaration:
  724.      GLOBALVALUEREF(int, ijk);
  725. declares the variable `ijk' as an array of type `int [1]'.  This is
  726. done because a globalvalue is actually a constant; its "value" is what
  727. the linker would normally consider an address.  That is not how an
  728. integer value works in C, but it is how an array works.  So treating
  729. the symbol as an array name gives consistent results--with the
  730. exception that the value seems to have the wrong type.  *Don't try to
  731. access an element of the array.*  It doesn't have any elements.  The
  732. array "address" may not be the address of actual storage.
  733.    The fact that the symbol is an array may lead to warnings where the
  734. variable is used.  Insert type casts to avoid the warnings.  Here is an
  735. example; it takes advantage of the ANSI C feature allowing macros that
  736. expand to use the same name as the macro itself.
  737.      GLOBALVALUEREF (int, ss$_normal);
  738.      GLOBALVALUEDEF (int, xyzzy,123);
  739.      #ifdef __GNUC__
  740.      #define ss$_normal ((int) ss$_normal)
  741.      #define xyzzy ((int) xyzzy)
  742.      #endif
  743.    Don't use `globaldef' or `globalref' with a variable whose type is
  744. an enumeration type; this is not implemented.  Instead, make the
  745. variable an integer, and use a `globalvaluedef' for each of the
  746. enumeration values.  An example of this would be:
  747.      #ifdef __GNUC__
  748.      GLOBALDEF (int, color, 0);
  749.      GLOBALVALUEDEF (int, RED, 0);
  750.      GLOBALVALUEDEF (int, BLUE, 1);
  751.      GLOBALVALUEDEF (int, GREEN, 3);
  752.      #else
  753.      enum globaldef color {RED, BLUE, GREEN = 3};
  754.      #endif
  755. File: gcc.info,  Node: VMS Misc,  Prev: Global Declarations,  Up: VMS
  756. Other VMS Issues
  757. ================
  758.    GNU CC automatically arranges for `main' to return 1 by default if
  759. you fail to specify an explicit return value.  This will be interpreted
  760. by VMS as a status code indicating a normal successful completion.
  761. Version 1 of GNU CC did not provide this default.
  762.    GNU CC on VMS works only with the GNU assembler, GAS.  You need
  763. version 1.37 or later of GAS in order to produce value debugging
  764. information for the VMS debugger.  Use the ordinary VMS linker with the
  765. object files produced by GAS.
  766.    Under previous versions of GNU CC, the generated code would
  767. occasionally give strange results when linked to the sharable `VAXCRTL'
  768. library.  Now this should work.
  769.    A caveat for use of `const' global variables: the `const' modifier
  770. must be specified in every external declaration of the variable in all
  771. of the source files that use that variable.  Otherwise the linker will
  772. issue warnings about conflicting attributes for the variable.  Your
  773. program will still work despite the warnings, but the variable will be
  774. placed in writable storage.
  775.    Although the VMS linker does distinguish between upper and lower case
  776. letters in global symbols, most VMS compilers convert all such symbols
  777. into upper case and most run-time library routines also have upper case
  778. names.  To be able to reliably call such routines, GNU CC (by means of
  779. the assembler GAS) converts global symbols into upper case like other
  780. VMS compilers.  However, since the usual practice in C is to distinguish
  781. case, GNU CC (via GAS) tries to preserve usual C behavior by augmenting
  782. each name that is not all lower case.  This means truncating the name
  783. to at most 23 characters and then adding more characters at the end
  784. which encode the case pattern of those 23.   Names which contain at
  785. least one dollar sign are an exception; they are converted directly into
  786. upper case without augmentation.
  787.    Name augmentation yields bad results for programs that use
  788. precompiled libraries (such as Xlib) which were generated by another
  789. compiler.  You can use the compiler option `/NOCASE_HACK' to inhibit
  790. augmentation; it makes external C functions and variables
  791. case-independent as is usual on VMS.  Alternatively, you could write
  792. all references to the functions and variables in such libraries using
  793. lower case; this will work on VMS, but is not portable to other
  794. systems.  The compiler option `/NAMES' also provides control over
  795. global name handling.
  796.    Function and variable names are handled somewhat differently with GNU
  797. C++.  The GNU C++ compiler performs "name mangling" on function names,
  798. which means that it adds information to the function name to describe
  799. the data types of the arguments that the function takes.  One result of
  800. this is that the name of a function can become very long.  Since the
  801. VMS linker only recognizes the first 31 characters in a name, special
  802. action is taken to ensure that each function and variable has a unique
  803. name that can be represented in 31 characters.
  804.    If the name (plus a name augmentation, if required) is less than 32
  805. characters in length, then no special action is performed.  If the name
  806. is longer than 31 characters, the assembler (GAS) will generate a hash
  807. string based upon the function name, truncate the function name to 23
  808. characters, and append the hash string to the truncated name.  If the
  809. `/VERBOSE' compiler option is used, the assembler will print both the
  810. full and truncated names of each symbol that is truncated.
  811.    The `/NOCASE_HACK' compiler option should not be used when you are
  812. compiling programs that use libg++.  libg++ has several instances of
  813. objects (i.e.  `Filebuf' and `filebuf') which become indistinguishable
  814. in a case-insensitive environment.  This leads to cases where you need
  815. to inhibit augmentation selectively (if you were using libg++ and Xlib
  816. in the same program, for example).  There is no special feature for
  817. doing this, but you can get the result by defining a macro for each
  818. mixed case symbol for which you wish to inhibit augmentation.  The
  819. macro should expand into the lower case equivalent of itself.  For
  820. example:
  821.      #define StuDlyCapS studlycaps
  822.    These macro definitions can be placed in a header file to minimize
  823. the number of changes to your source code.
  824. File: gcc.info,  Node: Portability,  Next: Interface,  Prev: VMS,  Up: Top
  825. GNU CC and Portability
  826. **********************
  827.    The main goal of GNU CC was to make a good, fast compiler for
  828. machines in the class that the GNU system aims to run on: 32-bit
  829. machines that address 8-bit bytes and have several general registers.
  830. Elegance, theoretical power and simplicity are only secondary.
  831.    GNU CC gets most of the information about the target machine from a
  832. machine description which gives an algebraic formula for each of the
  833. machine's instructions.  This is a very clean way to describe the
  834. target.  But when the compiler needs information that is difficult to
  835. express in this fashion, I have not hesitated to define an ad-hoc
  836. parameter to the machine description.  The purpose of portability is to
  837. reduce the total work needed on the compiler; it was not of interest
  838. for its own sake.
  839.    GNU CC does not contain machine dependent code, but it does contain
  840. code that depends on machine parameters such as endianness (whether the
  841. most significant byte has the highest or lowest address of the bytes in
  842. a word) and the availability of autoincrement addressing.  In the
  843. RTL-generation pass, it is often necessary to have multiple strategies
  844. for generating code for a particular kind of syntax tree, strategies
  845. that are usable for different combinations of parameters.  Often I have
  846. not tried to address all possible cases, but only the common ones or
  847. only the ones that I have encountered.  As a result, a new target may
  848. require additional strategies.  You will know if this happens because
  849. the compiler will call `abort'.  Fortunately, the new strategies can be
  850. added in a machine-independent fashion, and will affect only the target
  851. machines that need them.
  852.